package com.medaxis.hpams.sso.service.impl;

import com.medaxis.hpams.dto.global.ErrorException;
import com.medaxis.hpams.sso.constant.Constants;
import com.medaxis.hpams.sso.domain.dto.GroupDto;
import com.medaxis.hpams.sso.mapper.GroupMapper;
import com.medaxis.hpams.sso.service.GroupService;
import com.medaxis.hpams.sso.utils.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;


/**
 * 部门Service业务层处理
 *
 * @author ruoyi
 * @date 2021-08-24
 */
@Service
public class GroupServiceImpl implements GroupService {
    @Autowired
    private GroupMapper groupMapper;

    /**
     * 查询部门
     *
     * @param groupId 部门主键
     * @return 部门
     */
    @Override
    public GroupDto selectGroupByGroupId(Long groupId) {
        return groupMapper.selectGroupByGroupId(groupId);
    }

    /**
     * 查询部门列表
     *
     * @param GroupDto 组织
     * @return 部门
     */
    @Override
    public List<GroupDto> selectGroupList(GroupDto groupDto) {
        return groupMapper.selectGroupList(groupDto);
    }

    /**
     * 新增部门
     *
     * @param GroupDto 组织
     * @return 结果
     */
    @Override
    public int insertGroup(GroupDto groupDto) {

//
        GroupDto groupDto1 = groupMapper.selectGroupByGroupId(groupDto.getParentId());
//        如果父节点为不正常状态，则不允许新增节点

        if (Constants.GROUP_DISABLE.equals(groupDto1.getStatus())) {
            throw new ErrorException(Constants.GROUP_DISABLE_MESSAGE);
        }
        groupDto.setAncestors(groupDto1.getAncestors() +","+ groupDto1.getId());
        return groupMapper.insertGroup(groupDto);
    }

    /**
     * 修改部门
     *
     * @param GroupDto 组织
     * @return 结果
     */
    @Override
    public int updateGroup(GroupDto groupDto) {
//        查询父节点的数据
        GroupDto parentGroup = groupMapper.selectGroupByGroupId(groupDto.getParentId());
//       更新ancestor
        String oldAncestor = groupDto.getAncestors();
        String newAncestor = parentGroup.getAncestors() + "," + parentGroup.getId();
        groupDto.setAncestors(newAncestor);
//       跟新子组织的ancestor
        updateChildren(groupDto.getId(), oldAncestor, newAncestor);

//      如果启动该组织，该上级的状态都会被启用
        if (Constants.GROUP_NORMAL.equals(groupDto.getStatus())) {
            UpdateParentStatus(groupDto);
        }
        return groupMapper.updateGroup(groupDto);
    }


    /**
     * 更新子节点的状态
     *
     * @param id
     */
    private void UpdateParentStatus(GroupDto groupDto) {
        //todo 设置更新人
        GroupDto groupDto1 = groupMapper.selectGroupByGroupId(groupDto.getId());
        groupDto1.setUpdateBy("admin");
        groupMapper.updateParentStatus(groupDto1);
    }

    /**
     * 更新子节点的ancestor
     *
     * @param id
     */

    public void updateChildren(Long id, String oldAncestor, String newAncestor) {
        //        查询子节点
        List<GroupDto> children = groupMapper.selectChildren(id);

        if (StringUtils.isNotNull(children) && children.size() > 0) {
            children.forEach((s) -> {
                s.setAncestors(s.getAncestors().replace(oldAncestor, newAncestor));
            });
            //      更新子节点
            int i = groupMapper.updateChildren(children);
            if (i < 0 && StringUtils.isNotNull(children)) {
                throw new ErrorException(Constants.UPDATE_CHILDREN_ERROR);
            }
        }
    }

    /**
     * 批量删除部门
     *
     * @param groupIds 批量需要删除的部门Id
     * @return 结果
     */
    @Override
    public int deleteGroupByGroupIds(Long[] ids) {
        for (Long id : ids) {
//            查询该部门下面是否有用户
            if (groupMapper.findUserByGroupId(id) > 1) {
                throw new ErrorException("组织下存在用户不能删除");
            }
        }
        return groupMapper.deleteGroupByGroupIds(ids);
    }

    /**
     * 查询部门名称是否存在
     *
     * @param groupIds 批量需要删除的部门Id
     * @return 结果
     */


    @Override
    public String checkUnique(GroupDto groupDto) {
        Long id = StringUtils.isNull(groupDto.getId()) ? -1L : groupDto.getId();
        GroupDto groupDto1 = groupMapper.checkUnique(groupDto.getName(), groupDto.getParentId());
        if (StringUtils.isNotNull(groupDto1)&&groupDto1.getId().longValue() != id.longValue()) {
            return Constants.NOT_UNIQUE;
        }
        return Constants.UNIQUE;
    }
}
